home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 090 / vmed.arc / ED9.CCC < prev    next >
Text File  |  1985-12-03  |  3KB  |  170 lines
  1. /*    Screen editor:    general utilities
  2.  *
  3.  *    Module: ed9/ccc
  4.  *    Date: November 12, 1983
  5.  *    Changed: February 17, 1984
  6.  *    Changed: February 29, 1984 per VMEDFX.002
  7.  *    Changed: March 10, 1984 - accept last line w/o CR
  8.  *    Changed: July 5, 1984 - correct bug in 3-10 fix
  9.  */
  10.  
  11. #include ed0
  12.  
  13. /* Data global to this module */
  14.  
  15. int recalln;        /* remembered line number for goto etc. */
  16.  
  17. /* return: is first token in args a number ?
  18.  * return value of number in *val
  19.  *
  20.  * special cases made for 't'op, 'b'ottom and '.' (current line)
  21.  * and 'r'emembered line
  22.  */
  23. number(args,val)    char *args;    int *val;
  24. {    char    c;
  25.     unsigned    num;
  26.     switch (c = tolower(*args++))    {
  27.         case '.':
  28.             num = bufln(); break;
  29.         case 't':
  30.             num = 1; break;
  31.         case 'b':
  32.         case '$':
  33.             num = buffree(); break;
  34.         case 'r':
  35.             num = rememln(0); break;
  36.         case '0':
  37.         case '1':
  38.         case '2':
  39.         case '3':
  40.         case '4':
  41.         case '5':
  42.         case '6':
  43.         case '7':
  44.         case '8':
  45.         case '9':
  46.             num = c - '0';
  47.             while (isdigit(c = *args++))
  48.                 num = (num*10) + (c - '0');
  49.             break;
  50.         default:
  51.             return(NO);
  52.     }
  53.     *val = max(1, num);            /* 7-5-84 */
  54.     return(YES);
  55. }
  56.  
  57.  
  58. /* stores or returns remembered line */
  59.  
  60. rememln(line)    int line;
  61. {    if (line == 0)
  62.         return(recalln);
  63.     else
  64.         recalln = line;
  65. }
  66.  
  67. max(m,n)    int    m,n;    /* return maximum of m,n */
  68. {    return ((m > n) ? m : n);    }
  69.  
  70. min(m,n)    int    m,n;    /* return minimum of m,n */
  71. {    return ((m > n) ? n : m);    }
  72.  
  73. /* put decimal integer n in field width >= w.
  74.  * left justify the number in the field.
  75.  */
  76. putdec(n,w)    unsigned int n,w;    /* 03/03/84 jwk */
  77. {    char    chars[10];
  78.     int    i,nd;
  79.     nd = itoc(n,chars,10);
  80.     i = 0;
  81.     while (i < nd)
  82.         syscout(chars[i++]);
  83.     i = nd;
  84.     while (i++ < w)
  85.         syscout(' ');
  86. }
  87.  
  88. /* convert integer n to character string in str */
  89. itoc(n,str,size)    int n,size;    char *str;
  90. {    int    absval,len,i,j,k;
  91.     absval = abs(n);
  92. /* generate digits */
  93.     str[0] = 0;
  94.     i = 1;
  95.     while (i < size) {
  96.         str[i++] = (absval%10) + '0';
  97.         absval = absval/10;
  98.         if (absval == 0)
  99.             break;
  100.     }
  101. /* generate sign */
  102.     if ((i < size) & (n < 0))
  103.         str[i++] = '-';
  104.     len = i - 1;
  105. /* reverse sign, digits  */
  106.     --i;
  107.     j = 0;
  108.     while (j < i) {
  109.         k = str[i];
  110.         str[i] = str[j];
  111.         str[j] = k;
  112.         --i;
  113.         ++j;
  114.     }
  115.     return(len);
  116. }
  117.  
  118. /* return absolute value of n */
  119. abs(n)    int n;
  120. {    return ((n < 0) ? -n : n);    }
  121.  
  122. /* system error routine */
  123. syserr(s)    char *s;
  124. {    pmtmess("system error: ",s);    }
  125.  
  126. /* user error routine */
  127. error(s)    char *s;
  128. {    pmtmess("error: ",s);    }
  129.  
  130. /* read the next line of the file into
  131.  * the buffer of size n that p points to.
  132.  * Successive calls to readline() read the file
  133.  * from front to back.
  134.  */
  135. readline(file,p,n)    int file,n;    char *p;
  136. {    int    c,k;
  137.     k = 0;
  138.     FOREVER {
  139.         switch (c = sysrdch(file))    {
  140.             case EOF:
  141.                 return (k > 0 ? k : EOF);    /* 7-5-84 */
  142.             case ERR:
  143.                 return(ERR);
  144.             case CR:
  145.                 return(k);
  146.             default:
  147.                 break;
  148.         }
  149.         if (k < n)
  150.             *p++ = c;    /* move character to buffer */
  151.         ++k;            /* always bump count */
  152.     }
  153. }
  154.  
  155. /* push (same as write) line to end of file.
  156.  * line is in the buffer of size n that p points to.
  157.  */
  158. pushline(file,p,n)    int file,n;    char *p;
  159. {
  160. /* write all but trailing CR */
  161.     while ((n--) > 0)
  162.         if (syspshch(*p++,file) == ERR)
  163.             return(ERR);
  164. /* write trailing CR */
  165.     return(syspshch(CR,file));
  166. }
  167.  
  168. /* end module ed9/ccc */
  169. 
  170.